#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <arpa/inet.h> //包含sockaddr_in结构
#include <unistd.h>
#include "sock.hpp"
#include<sys/select.h>
#include<sys/poll.h>
#include<functional>

// 这个数字作为我们初始化得大小，为什么这么设置。首先我们要知道这个结构体是位图，本质就是结构体里面套了一个数组。
// struct selectServer
// {
//    int *arr[10]
// };

// 一个int就占用4个字节 ，就可以表示32位数，当我们求得这个结构体得大小得时候，其实就是求了这个结构体得大小，这个结构体里面只有数组
namespace select_ns
{
    using func_t = std::function<std::string (const std::string&)>;
    static const uint16_t gport = 8080;
    static const int rfdnum = 2048;
    static const int defaultfd = -1;
    class PollServer
    {
    public:
        PollServer(func_t func,uint16_t port = gport)
            : _port(port), _listenSock(-1),_func(func)
        {
        }

        void Print()
        {
            std::cout << "fd list: ";
            for (int i = 0; i < rfdnum; i++)
            {
                if (rfds[i].fd != defaultfd)
                    std::cout << rfds[i].fd << " ";
            }
            std::cout << std::endl;
        }
        void Accepter(int listensock)
        {
            std::string clientip;
            uint16_t clientport=0;
            int sock = Sock::Accept(listensock, &clientip, &clientport);
            if(sock<0)
            {
                logMessage(NORMAL,"accept error");
                exit(ACCEPT_ERR);
            }
            logMessage(NORMAL, "accept success [%s:%d]", clientip.c_str(), clientport);
            // 将这个sock 和 listen sock分离
            // 找到sock的插入位置
            int i= 0;
            for(;i<rfdnum;i++)
            {
                // 说明位置不是插入的位置
                if(rfds[i].fd!=defaultfd)
                {
                    continue;
                }
                break;
            }
            if(i==(rfdnum-1))
            {
                logMessage(NORMAL,"位置满了，请稍后再试");
            }else{
                rfds[i].fd=sock;
                rfds[i].events=POLLIN;
                rfds[i].revents=0;
            }
            Print();

        }

        void Recver(int pos)
        {
            char buffer[1024];
            ssize_t s = recv(rfds[pos].fd, buffer, sizeof(buffer) - 1, 0); // 这里在进行读取的时候，会不会被阻塞？1， 0
            if (s > 0)
            {
                buffer[s] = 0;
                logMessage(NORMAL, "client# %s", buffer);
            }
            else if (s == 0)
            {

                close(rfds[pos].fd);
                RsetRfds(pos);
                logMessage(NORMAL, "client quit");
                return;
            }
            else
            {
                close(rfds[pos].fd);
                RsetRfds(pos);
                logMessage(ERROR, "client quit: %s", strerror(errno));
                return;
            }
            // 2. 处理request
            std::string response = _func(buffer);
            std::cout<<response<<std::endl;

            // 3. 返回response
            // write bug
            write(rfds[pos].fd, response.c_str(), response.size());

            logMessage(DEBUG, "out Recver");
        }
        void RsetRfds(int pos)
        {
            rfds[pos].fd=defaultfd;
            rfds[pos].events=0;
            rfds[pos].revents=0;
        }
        void HandlerEvent()
        {
            for (int i = 0; i < rfdnum; i++)
            {
                // 过滤掉非法的fd
                if (rfds[i].fd == defaultfd)
                    continue;

                // 正常的fd
                // 正常的fd不一定就绪了
                // 目前一定是listensock，只有这一个
                if (!(rfds[i].events & POLLIN))
                {
                    continue;
                }

                
                if (rfds[i].fd==_listenSock && (rfds[i].revents&POLLIN))
                    Accepter(_listenSock);
                else if (rfds[i].revents&POLLIN)
                    Recver(i);
                else
                {
                }
            }
        }
        void initServer()
        {
            _listenSock = Sock::getSocket();
            Sock::Bind(_listenSock, _port);
            Sock::Listen(_listenSock);
            // 考虑初始化为多大
            // 创建失败
            rfds = new pollfd[rfdnum];
            if(rfds==nullptr)
            {
               logMessage(FATAL,"pollfd create err");
               exit(POLLFD_ERR);
            }
            // 初始化
            for(int i=0;i<rfdnum;i++)
            {
                RsetRfds(i);
            }
            rfds[0].fd=_listenSock;
            rfds[0].events=POLLIN;
            rfds[0].revents=0;   
        }

        void start()
        {
            for (;;)
            {
                // int poll(struct pollfd *fds, nfds_t nfds, int timeout);
                int time =1000;
                int n = poll(rfds,rfdnum,time);
                switch (n)
                {
                case 0:
                    logMessage(NORMAL, "time out...");
                    break;
                case -1:
                    logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
                    break;
                default:
                    logMessage(NORMAL, "get a new link...");
                    HandlerEvent();
                    break;
                }
            }
        }
        ~PollServer()
        {
            if (_listenSock < 0)
                close(_listenSock);
            if (rfds)
                delete[] rfds;
        }

    private:
        int _listenSock;
        uint16_t _port;
        struct pollfd* rfds;
        func_t _func;
    };

}
